from django.db import models
from django.db.models import manager


# class asset(models.Model):
#     '''
#     资产表
#     '''
#     assetTypeChoices = (
#         ('server', '服务器'),
#         ('networkDevice', '网络设备'),
#         ('securityDevice', '安全设备'),
#         ('securityDevice', '机房设备'),
#         ('switch', '交换机'),
#         ('router', '路由器'),
#         ('firewall', '防火墙'),
#         ('storage', '存储设备'),
#         ('NLB', 'NetScaler'),
#         ('wireless', '无线AP'),
#         ('software', '软件资产'),
#         ('others', '其它类'),
#     )

#     asset_type = models.CharField(
#         choices=assetTypeChoices, max_length=64, default='server')  # 资产类型选择。默认是服务器
#     name = models.CharField(max_length=64, unique=True)

#     sn = models.CharField('资产SN号', max_length=128, unique=True)
#     manufactory = models.ForeignKey(
#         'Manufactory', verbose_name='制造商', null=True, blank=True, on_delete=models.CASCADE)  # 和Manufactory厂商表是一对多的关系，

#     # model = models.ForeignKey('ProductModel', verbose_name=u'型号')
#     # model = models.CharField(u'型号',max_length=128,null=True, blank=True )

#     management_ip = models.GenericIPAddressField(
#         '管理IP', blank=True, null=True)  # 记录的该资产的管理IP或者网卡IP。由自己决定存储哪方面IP。
#     contract = models.ForeignKey(
#         'Contract', verbose_name='合同', null=True, blank=True, on_delete=models.CASCADE)

#     trade_date = models.DateField(
#         '购买时间', null=True, blank=True)  # 购买该资产的交易时间。可以为空。
#     expire_date = models.DateField(
#         '过保修期', null=True, blank=True)  # 该资产的过保时间，字段可以为空。

#     price = models.FloatField('价格', null=True, blank=True)
#     business_unit = models.ForeignKey(
#         'BusinessUnit', verbose_name='所属业务线', null=True, blank=True, on_delete=models.CASCADE)
#     tags = models.ManyToManyField('Tag', blank=True)

#     # 管理员：我理解是维护人员的，和表：userProfile是的一对多关系。
#     admin = models.ForeignKey(
#         'UserProfile', verbose_name='资产管理员', null=True, blank=True, on_delete=models.CASCADE)
#     # 属于哪个idc机房，和表idc是一对多关系。可以为空（未分配机器）
#     idc = models.ForeignKey('IDC', verbose_name='IDC机房',
#                             null=True, blank=True, on_delete=models.CASCADE)

#     # 该设备状态和监控系统相关联：处于上线还是下线。
#     # status = models.ForeignKey('Status', verbose_name=u'设备状态', default=1,on_delete=models.CASCADE)
#     # Configuration = models.OneToOneField(
#     #     'Configuration', verbose_name='配置管理', blank=True, null=True,on_delete=models.CASCADE)  # 和saltstack关联。

#     memo = models.TextField('备注', null=True, blank=True)  # 设备备注信息。
#     create_date = models.DateTimeField(
#         blank=True, auto_now_add=True)  # 资产创建日期。

#     update_date = models.DateTimeField(blank=True, auto_now=True)  # 资产更新时间

#     class Meta:
#         db_table = 'assetType'
#         managed = True
#         verbose_name = '资产总表'
#         verbose_name_plural = verbose_name

#     def __str__(self):
#         return self.name


# class server(models.Model):
#     '''
#       服务器信息表：存储服务器类型、raid卡类型，操作系统的类型等信息。
#       因为硬盘和内存、cpu和服务器关系是一对多，而服务器是父表，所以在该表中未体现
#       该信息。
#     '''
#     asset = models.OneToOneField(
#         'Asset', on_delete=models.CASCADE)  # 服务器和对应服务器的资产是一对一的关系。不可能出现一对多或者多对多关系。
#     subAsssetTypeChoices = (
#         (0, 'PC服务器'),
#         (1, 'PC服务器'),
#         (2, '小型机'),
#     )
#     created_by_choices = (
#         ('auto', 'Auto'),
#         ('manual', 'Manual'),
#     )
#     sub_asset_type = models.SmallIntegerField(
#         choices=subAsssetTypeChoices, verbose_name="服务器类型", default=0)
#     # 服务器类型。不需要在创建一个表关联，choice字段就可以指定。因为只是单个字段而不是多个字段属性无需创建表。
#     created_by = models.CharField(
#         choices=created_by_choices, max_length=32, default='auto')
#     # 该字段是说明该服务器是手工录入还是自动录入，因为手工录入准确性比较低允许用户进行修改。而自动录入的准确率较高，在程序层面上不允许修改。
#     hosted_on = models.ForeignKey('self', related_name='hosted_on_server',
#                                   blank=True, null=True, on_delete=models.CASCADE)  # for vitural server

#     # sn = models.CharField(u'SN号',max_length=128)
#     # management_ip = models.CharField(u'管理IP',max_length=64,blank=True,null=True)
#     # manufactory = models.ForeignKey(verbose_name=u'制造商',max_length=128,null=True, blank=True)
#     '''
#     sn management_ip manufactory 属于公用字段，所以保存在资产表asset中。
#     '''
#     model = models.CharField(
#         verbose_name=u'型号', max_length=128, null=True, blank=True)
#     # 服务器型号。
#     # 若有多个CPU，型号应该都是一致的，故没做ForeignKey
#     raid_type = models.CharField(
#         'raid类型', max_length=512, blank=True, null=True)
#     # raid卡类型，每个服务器的raid卡的类型。

#     # nic = models.ManyToManyField('NIC', verbose_name=u'网卡列表')
#     # disk
#     # physical_disk_driver = models.ManyToManyField('Disk', verbose_name=u'硬盘',blank=True,null=True)
#     # raid_adaptor = models.ManyToManyField('RaidAdaptor', verbose_name=u'Raid卡',blank=True,null=True)
#     # memory
#     # ram_capacity = models.IntegerField(u'内存总大小GB',blank=True)
#     # ram = models.ManyToManyField('Memory', verbose_name=u'内存配置',blank=True,null=True)
#     '''
#     网卡、硬盘、内存等和服务器关系是一对多的关系，而server表属于父表，所以foreignkey需要建立在disk、nic、memory表中。
#     所以server表中没记录。
#     '''

#     os_type = models.CharField('操作系统类型', max_length=64, blank=True, null=True)
#     # 操作系统的类型：比如：centos5、6、7等
#     os_distribution = models.CharField(
#         '发型版本', max_length=64, blank=True, null=True)
#     # 系统发行版本。
#     os_release = models.CharField(
#         '操作系统版本', max_length=64, blank=True, null=True)
#     # 操作系统版本。

#     class Meta:
#         db_table = 'serverInfo'
#         managed = True
#         verbose_name = '服务器信息'
#         verbose_name_plural = verbose_name

#     def __str__(self) -> str:
#         return self.asset.name


# class securityDevice(models.Model):
#     '''
#     安全设备信息表：存储是安全设备表，需要存储的信息，最好跟相应的维护人沟通。
#     '''
#     asset = models.OneToOneField('Asset', on_delete=models.CASCADE)
#     # 和资产表asset关系是一对一关系。
#     subAsssetTypeChoices = (
#         (0, '防火墙'),
#         (1, '入侵检测设备'),
#         (2, '互联网网关'),
#         (4, '运维审计系统'),
#     )
#     sub_asset_type = models.SmallIntegerField(
#         choices=subAsssetTypeChoices, verbose_name="服务器类型", default=0)
#     # 设备类型。

#     class Meta:
#         db_table = 'securityInfo'
#         managed = True
#         verbose_name = '安全设备信息'
#         verbose_name_plural = verbose_name

#     def __str__(self):
#         return self.asset.id


# class networkDevice(models.Model):
#     '''
#     网络设备表：该表存储：vlanip、intranet_ip、型号等。
#     '''
#     asset = models.OneToOneField('Asset', on_delete=models.CASCADE)
#     # 和资产表asset关系是一对一的关系。
#     subAsssetTypeChoices = (
#         (0, '路由器'),
#         (1, '交换机'),
#         (2, '负载均衡'),
#         (4, 'VPN设备'),
#     )
#     sub_asset_type = models.SmallIntegerField(
#         choices=subAsssetTypeChoices, verbose_name="服务器类型", default=0)
#     # 网络设备的类型。
#     vlan_ip = models.GenericIPAddressField('VlanIP', blank=True, null=True)
#     intranet_ip = models.GenericIPAddressField('内网IP', blank=True, null=True)
#     #sn = models.CharField(u'SN号',max_length=128,unique=True)
#     #manufactory = models.CharField(verbose_name=u'制造商',max_length=128,null=True, blank=True)
#     '''
#     sn manufactory 存储到总表中。
#     '''
#     model = models.CharField('型号', max_length=128, null=True, blank=True)
#     # 型号。
#     firmware = models.CharField(blank=True, null=True, max_length=128)
#     #firmware = models.ForeignKey('Software',blank=True,null=True)
#     # 每个网络设备的固件应该和设备绑定在一起，而不是单独算作资产。
#     port_num = models.SmallIntegerField('端口个数', null=True, blank=True)
#     # 每个网络设备的端口数目。
#     device_detail = models.TextField('设置详细配置', null=True, blank=True)
#     # 每个设备的配置表。
#     # 网络中心VIP
#     vip_ip = models.GenericIPAddressField("vip", blank=True, null=True)

#     class Meta:
#         db_table = 'networkInfo'
#         managed = True
#         verbose_name = '网络设备'
#         verbose_name_plural = verbose_name


# class softwareSys(models.Model):
#     '''
#     only save software which company purchased
#     即只有话费一定的成本才叫做资产。
#     '''
#     osTypesChoice = (
#         (0, 'OS'),
#         (1, '办公\开发软件'),
#         (2, '业务软件'),

#     )
#     license_num = models.IntegerField(verbose_name="授权数")
#     # 授权码。
#     # os_distribution_choices = (('windows','Windows'),
#     #                            ('centos','CentOS'),
#     #                            ('ubuntu', 'Ubuntu'))
#     # type = models.CharField(u'系统类型', choices=os_types_choice, max_length=64,help_text=u'eg. GNU/Linux',default=1)
#     # distribution = models.CharField(u'发型版本', choices=os_distribution_choices,max_length=32,default='windows')
#     version = models.CharField(
#         '软件/系统版本', max_length=64, help_text=u'eg. CentOS release 6.5 (Final)', unique=True)
#     # 软件版本。
#     # language_choices = (('cn',u'中文'),
#     #                     ('en',u'英文'))
#     # language = models.CharField(u'系统语言',choices = language_choices, default='cn',max_length=32)
#     # #version = models.CharField(u'版本号', max_length=64,help_text=u'2.6.32-431.3.1.el6.x86_64' )

#     class Meta:
#         db_table = 'softwareInfo'
#         managed = True
#         verbose_name = '软件系统'
#         verbose_name_plural = verbose_name

#     def __str__(self):
#         return self.version


# class CPU(models.Model):
#     '''
#     存储cpu表：因为服务器上cpu的型号是必须一致，否则运行不了，所以和服务器对应的资产表是一对一关系。
#     '''

#     asset = models.OneToOneField(
#         'Asset', on_delete=models.CASCADE)  # 必须和服务器资产是一对一的关系。
#     cpu_model = models.CharField('CPU型号', max_length=128, blank=True)
#     # cpu型号。
#     cpu_count = models.SmallIntegerField('物理cpu个数')
#     # 物理cpu的数量。
#     cpu_core_count = models.SmallIntegerField('cpu核数')
#     # cpu的核数。
#     memo = models.TextField('备注', null=True, blank=True)
#     # 备注
#     create_date = models.DateTimeField(auto_now_add=True)
#     # 数据创建日期。
#     update_date = models.DateTimeField(blank=True, null=True)
#     # cpu配件更新日期。

#     class Meta:
#         db_table = 'cpu'
#         managed = True
#         verbose_name = 'CPU部件'
#         verbose_name_plural = verbose_name

#     def __str__(self):
#         return self.cpu_model


# class RAM(models.Model):
#     '''
#     存储内存表。
#     '''
#     asset = models.ForeignKey(
#         'Asset', on_delete=models.CASCADE)  # 和服务器资产表是一对多的关系。
#     sn = models.CharField('SN号', max_length=128, blank=True, null=True)
#     # sn号，但并不唯一。
#     model = models.CharField('内存型号', max_length=128)
#     # 内存型号。
#     slot = models.CharField('插槽', max_length=64)
#     # 内存插槽。
#     capacity = models.IntegerField(u'内存大小(MB)')
#     # 内存大小单位M
#     memo = models.CharField('备注', max_length=128, blank=True, null=True)
#     # 备注。
#     create_date = models.DateTimeField(blank=True, auto_now_add=True)
#     # 创建日期。但不一定是服务器使用该内存的日期。
#     update_date = models.DateTimeField(blank=True, null=True)
#     # 更新内存配件日期。

#     def __str__(self):
#         return '%s:%s:%s' % (self.asset_id, self.slot, self.capacity)

#     class Meta:
#         db_table = 'RAM'
#         managed = True
#         verbose_name = 'RAM'
#         verbose_name_plural = verbose_name
#         unique_together = ("asset", "slot")
#         '''
#         怎么确定一个内存是唯一呢？因为搜集的SN的号有时候搜集不到，所以没定义SN为唯一。我们只能通过插槽和对应的服务器来确定内存的。
#         所以和服务器资产和插槽做联合唯一。
#         '''
#     auto_create_fields = ['sn', 'slot', 'model', 'capacity']


# class disk(models.Model):
#     '''
#     硬盘储存表。
#     '''
#     asset = models.ForeignKey(
#         'Asset', on_delete=models.CASCADE)  # 和服务器资产表关系一对多。
#     sn = models.CharField('SN号', max_length=128, blank=True, null=True)
#     '''
#     硬盘的sn号有时候抓不到。所以不唯一。
#     '''
#     slot = models.CharField('插槽位', max_length=64)
#     # 硬盘插槽字段。
#     #manufactory = models.CharField(u'制造商', max_length=64,blank=True,null=True)
#     model = models.CharField('磁盘型号', max_length=128, blank=True, null=True)
#     # 硬盘型号。
#     capacity = models.FloatField('磁盘容量GB')
#     # 硬盘容量。
#     disk_iface_choice = (  # 硬盘接口类型。
#         ('SATA', 'SATA'),
#         ('SAS', 'SAS'),
#         ('SCSI', 'SCSI'),
#         ('SSD', 'SSD'),
#     )

#     iface_type = models.CharField(
#         '接口类型', max_length=64, choices=disk_iface_choice, default='SAS')  # 硬盘接口类型。
#     memo = models.TextField('备注', blank=True, null=True)  # 备注。
#     create_date = models.DateTimeField(blank=True, auto_now_add=True)  # 创建日期。
#     update_date = models.DateTimeField(blank=True, null=True)  # 硬盘更新日期。

#     auto_create_fields = ['sn', 'slot', 'manufactory',
#                           'model', 'capacity', 'iface_type']

#     class Meta:
#         db_table = 'DISK'
#         managed = True
#         unique_together = ("asset", "slot")
#         verbose_name = '硬盘'
#         verbose_name_plural = verbose_name

#     def __str__(self):
#         return '%s:slot:%s capacity:%s' % (self.asset_id, self.slot, self.capacity)


# class NIC(models.Model):
#     '''
#     网卡存储表。
#     '''
#     asset = models.ForeignKey(
#         'Asset', on_delete=models.CASCADE)  # 网卡和对应设备资产的关系是一对多的关系。
#     name = models.CharField('网卡名', max_length=64,
#                             blank=True, null=True)  # 网卡的名字。
#     sn = models.CharField('SN号', max_length=128, blank=True,
#                           null=True)  # 网卡的sn，有时候并不能抓大信息
#     model = models.CharField('网卡型号', max_length=128,
#                              blank=True, null=True)  # 网卡型号。
#     macaddress = models.CharField(
#         u'MAC', max_length=64, unique=True)  # MAC地址，需要注意这个字段是唯一的。
#     # 网卡的ip 因为一个服务器上的网卡不一定有IP，还有vip情况，所以不是唯一。可为空。
#     ipaddress = models.GenericIPAddressField('IP', blank=True, null=True)
#     netmask = models.CharField(
#         max_length=64, blank=True, null=True)  # 网卡的子网掩码。
#     bonding = models.CharField(max_length=64, blank=True, null=True)  # 绑定IP
#     memo = models.CharField('备注', max_length=128,
#                             blank=True, null=True)  # 网卡的备注信息。
#     create_date = models.DateTimeField(
#         blank=True, auto_now_add=True)  # 数据的创建日期。
#     update_date = models.DateTimeField(blank=True, null=True)  # 网卡更新的时间。

#     def __str__(self):
#         return '%s:%s' % (self.asset_id, self.macaddress)

#     class Meta:
#         db_table = 'NIC'
#         managed = True
#         verbose_name = u'网卡'
#         verbose_name_plural = verbose_name
#         #unique_together = ("asset_id", "slot")
#         unique_together = ("asset", "macaddress")  # 通过mac地址和服务器资产的来唯一确认网卡的唯一。
#     auto_create_fields = ['name', 'sn', 'model',
#                           'macaddress', 'ipaddress', 'netmask', 'bonding']


# class raidAdaptor(models.Model):
#     '''
#     RAID的卡存储表。一个服务器上可以有多个raid卡。
#     '''
#     asset = models.ForeignKey(
#         'Asset', on_delete=models.CASCADE)  # 和服务器资产关系式多对一的关系。
#     sn = models.CharField('SN号', max_length=128, blank=True,
#                           null=True)  # 不是唯一的，因为有些sn号收集不到。
#     slot = models.CharField('插口', max_length=64)  # raid卡插口。
#     model = models.CharField(
#         '型号', max_length=64, blank=True, null=True)  # raid卡型号。
#     memo = models.TextField('备注', blank=True, null=True)  # raid卡备注。
#     create_date = models.DateTimeField(
#         blank=True, auto_now_add=True)  # 数据创建日期。
#     update_date = models.DateTimeField(blank=True, null=True)  # raid卡更新日期。

#     def __str__(self):
#         return self.name

#     class Meta:
#         db_table = 'raid'
#         managed = True
#         verbose_name = '存储阵列'
#         verbose_name_plural = verbose_name
#         unique_together = ("asset", "slot")  # 通过插槽和服务器资产来唯一确定raid卡的唯一。


# class manufactory(models.Model):
#     '''
#     厂商存储表。
#     '''
#     manufactory = models.CharField(
#         '厂商名称', max_length=64, unique=True)  # 厂商名称存字段。
#     support_num = models.CharField('支持电话', max_length=30, blank=True)  # 厂商电话。
#     memo = models.CharField('备注', max_length=128, blank=True)  # 厂商备注。

#     def __str__(self):
#         return self.manufactory

#     class Meta:
#         db_table = 'manufactory'
#         managed = True
#         verbose_name = '厂商'
#         verbose_name_plural = verbose_name


# class businessUnit(models.Model):
#     '''
#     业务线存储表。
#     '''
#     parent_unit = models.ForeignKey(
#         'self', related_name='parent_level', blank=True, null=True, on_delete=models.CASCADE)
#     # 自关联，当一个业务线有子业务线的时候，需要跟自身做foreignkey。
#     name = models.CharField('业务线', max_length=64, unique=True)
#     # 业务线名字。
#     #contact = models.ForeignKey('UserProfile',default=None)
#     memo = models.CharField('备注', max_length=64, blank=True)  # 业务线的备注。

#     def __str__(self):
#         return self.name

#     class Meta:
#         db_table = 'business'
#         managed = True
#         verbose_name = '业务线'
#         verbose_name_plural = verbose_name


# class contract(models.Model):
#     '''
#     存储合同表。
#     '''
#     sn = models.CharField('合同号', max_length=128, unique=True)  # 合同号。
#     name = models.CharField('合同名称', max_length=64)  # 合同名称。
#     memo = models.TextField('备注', blank=True, null=True)  # 备注。
#     price = models.IntegerField('合同金额')  # 合同金额。
#     detail = models.TextField('合同详细', blank=True, null=True)
#     start_date = models.DateField(blank=True)  # 合同生效期
#     end_date = models.DateField(blank=True)  # 合同失效日期。
#     license_num = models.IntegerField('license数量', blank=True)  # 证书数量。
#     create_date = models.DateField(auto_now_add=True)  # 合同录入日期。
#     update_date = models.DateField(auto_now=True)  # 合同更新日期。

#     class Meta:
#         db_table = 'contract'
#         managed = True
#         verbose_name = '合同'
#         verbose_name_plural = verbose_name

#     def __str__(self):
#         return self.name


# class IDC(models.Model):
#     '''
#     存储机房表。
#     '''
#     name = models.CharField('机房名称', max_length=64, unique=True)  # 机房名称，是唯一的。
#     memo = models.CharField('备注', max_length=128,
#                             blank=True, null=True)  # 机房备注。

#     def __str__(self):
#         return self.name

#     class Meta:
#         db_table = 'IDC'
#         managed = True
#         verbose_name = '机房'
#         verbose_name_plural = verbose_name


# class tag(models.Model):
#     '''
#     资产标签，可以给每个资产定义不同的名臣的，方便我们多维度去查询机器。
#     '''
#     name = models.CharField('Tag name', max_length=32,
#                             unique=True)  # 标签的名字是唯一的。
#     creater = models.ForeignKey(
#         'UserProfile', on_delete=models.CASCADE)  # 打标签的人。
#     create_date = models.DateField(auto_now_add=True)  # 标签创建时间。

#     class Meta:
#         db_table = 'tag'
#         managed = True
#         verbose_name = '标签'
#         verbose_name_plural = verbose_name

#     def __str__(self):
#         return self.name


# class eventLog(models.Model):
#     '''
#     时间变更日志存储的表。
#     '''
#     name = models.CharField(u'事件名称', max_length=100)  # 事件名称。
#     event_type_choices = (
#         (1, u'硬件变更'),
#         (2, u'新增配件'),
#         (3, u'设备下线'),
#         (4, u'设备上线'),
#         (5, u'定期维护'),
#         (6, u'业务上线\更新\变更'),
#         (7, u'其它'),
#     )
#     event_type = models.SmallIntegerField(
#         u'事件类型', choices=event_type_choices)  # 事件类型。
#     asset = models.ForeignKey(
#         'Asset', on_delete=models.CASCADE)  # 和资产的关系式一对多的关系。
#     # 时间子项，比如说：一个服务器的网卡变更操作，叫做子项。
#     component = models.CharField('事件子项', max_length=255, blank=True, null=True)
#     detail = models.TextField(u'事件详情')  # 时间的内容。
#     date = models.DateTimeField(u'事件时间', auto_now_add=True)  # 事件产生的日期。
#     user = models.ForeignKey(
#         'UserProfile', verbose_name=u'事件源', on_delete=models.CASCADE)  # 事件的发起者。
#     memo = models.TextField(u'备注', blank=True, null=True)  # 事件备注。

#     def __str__(self):
#         return self.name

#     class Meta:
#         db_table = 'eventLog'
#         managed = True
#         verbose_name = '事件纪录'
#         verbose_name_plural = verbose_name

#     def colored_event_type(self):
#         if self.event_type == 1:
#             cell_html = '<span style="background: orange;">%s</span>'
#         elif self.event_type == 2:
#             cell_html = '<span style="background: yellowgreen;">%s</span>'
#         else:
#             cell_html = '<span >%s</span>'
#         return cell_html % self.get_event_type_display()
#     colored_event_type.allow_tags = True
#     colored_event_type.short_description = u'事件类型'


# class newAssetApprovalZone(models.Model):
#     '''
#     备件储存表。
#     '''
#     sn = models.CharField(u'资产SN号', max_length=128, unique=True)  # 备件名称。是唯一的。
#     asset_type_choices = (
#         ('server', u'服务器'),
#         ('switch', u'交换机'),
#         ('router', u'路由器'),
#         ('firewall', u'防火墙'),
#         ('storage', u'存储设备'),
#         ('NLB', u'NetScaler'),
#         ('wireless', u'无线AP'),
#         ('software', u'软件资产'),
#         ('others', u'其它类'),
#     )
#     asset_type = models.CharField(
#         choices=asset_type_choices, max_length=64, blank=True, null=True)  # 备件类型。
#     manufactory = models.CharField(
#         max_length=64, blank=True, null=True)  # 备件厂商。
#     model = models.CharField(max_length=128, blank=True, null=True)  # 备件类型。
#     ram_size = models.IntegerField(blank=True, null=True)  # 备件内存大小。
#     cpu_model = models.CharField(
#         max_length=128, blank=True, null=True)  # 备件cpu型号。
#     cpu_count = models.IntegerField(blank=True, null=True)  # 备件物理cpu个数。
#     cpu_core_count = models.IntegerField(blank=True, null=True)  # 备件cpu核数。
#     os_distribution = models.CharField(
#         max_length=64, blank=True, null=True)  # 系统版本
#     os_type = models.CharField(max_length=64, blank=True, null=True)  # 系统类型。
#     os_release = models.CharField(
#         max_length=64, blank=True, null=True)  # 系统发行版本。
#     data = models.TextField('资产数据')  # 资产数据。
#     date = models.DateTimeField('汇报日期', auto_now_add=True)  # 资产录入日期。
#     approved = models.BooleanField(u'已批准', default=False)  # 资产审批状态。
#     approved_by = models.ForeignKey(
#         'UserProfile', verbose_name=u'批准人', blank=True, null=True, on_delete=models.CASCADE)  # 批准人，
#     approved_date = models.DateTimeField(
#         u'批准日期', blank=True, null=True)  # 批准日期。

#     def __str__(self):
#         return self.sn

#     class Meta:
#         db_table = 'assetApproval'
#         managed = True
#         verbose_name = '新上线待批准资产'
#         verbose_name_plural = verbose_name


# class UserProfile(models.Model):
#     '''
#     管理员表。继承User类。使用django的用户认证。
#     '''
#     name = models.CharField("姓名", max_length=32)  # 用户名。

#     def __str__(self):
#         return self.name

#     class Meta:
#         db_table = "user"
#         managed = True
#         verbose_name = '用户'
#         verbose_name_plural = verbose_name


class manualInfo(models.Model):
    """
    手动录入资产信息列表 
    """
    name = models.CharField(max_length=24, verbose_name="主机名")
    hostip = models.GenericIPAddressField(
        blank=True, null=True, verbose_name="主机IP")
    netmask = models.GenericIPAddressField(
        blank=True, null=True, verbose_name="主机网络")
    hostdisk = models.CharField(max_length=32, verbose_name="主机磁盘大小")
    hostcpu = models.CharField(max_length=32, verbose_name="主机cpu大小")
    hostmemory = models.CharField(max_length=32, verbose_name="主机内存大小")
    create_date = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    update_date = models.DateTimeField(auto_now=True, verbose_name="更新时间")

    class Meta:
        db_table = 'manualInfo'
        managed = True
        verbose_name = '手动录入主机信息'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name
